/**
 * 日期时间工具类
 * 统一管理项目中所有的日期时间格式化函数
 */

/**
 * 格式化相对时间（如：刚刚、5分钟前、2小时前等）
 * @param {string|Date|number} dateInput - 日期字符串、Date对象或时间戳
 * @returns {string} 格式化后的相对时间字符串
 */
const formatTime = (dateInput) => {
  if (!dateInput) return ''

  const date = new Date(dateInput)
  const now = Date.now()
  const diff = now - date.getTime()
  
  // 时间单位常量
  const minute = 60 * 1000
  const hour = 60 * minute
  const day = 24 * hour
  const week = 7 * day

  // 小于1分钟
  if (diff < minute) {
    return '刚刚'
  }
  
  // 小于1小时
  if (diff < hour) {
    const minutes = Math.floor(diff / minute)
    return `${minutes}分钟前`
  }
  
  // 小于24小时
  if (diff < day) {
    const hours = Math.floor(diff / hour)
    return `${hours}小时前`
  }
  
  // 小于7天
  if (diff < week) {
    const days = Math.floor(diff / day)
    return `${days}天前`
  }
  
  // 超过7天，显示具体日期
  return formatDate(date)
}

/**
 * 判断两个日期是否为同一天
 * @param {string|Date|number} date1 - 第一个日期
 * @param {string|Date|number} date2 - 第二个日期
 * @returns {boolean} 是否为同一天
 */
const isSameDay = (date1, date2) => {
  if (!date1 || !date2) return false
  
  const d1 = new Date(date1)
  const d2 = new Date(date2)
  
  return d1.getFullYear() === d2.getFullYear() &&
         d1.getMonth() === d2.getMonth() &&
         d1.getDate() === d2.getDate()
}

/**
 * 格式化日期为中文格式
 * @param {string|Date|number} dateInput - 日期字符串、Date对象或时间戳
 * @param {boolean} includeYear - 是否包含年份，默认为智能判断（当年不显示年份）
 * @returns {string} 格式化后的日期字符串（如：12月25日 或 2023年12月25日）
 */
const formatDate = (dateInput, includeYear = null) => {
  if (!dateInput) return ''

  const date = new Date(dateInput)
  const year = date.getFullYear()
  const month = date.getMonth() + 1
  const day = date.getDate()
  
  const currentYear = new Date().getFullYear()
  
  // 如果没有明确指定是否包含年份，则智能判断
  if (includeYear === null) {
    includeYear = year !== currentYear
  }
  
  if (includeYear) {
    return `${year}年${month}月${day}日`
  } else {
    return `${month}月${day}日`
  }
}

/**
 * 格式化完整的日期时间（用于详细显示）
 * @param {string|Date|number} dateInput - 日期字符串、Date对象或时间戳
 * @param {boolean} includeSeconds - 是否包含秒数，默认为false
 * @returns {string} 格式化后的完整日期时间字符串
 */
const formatDateTime = (dateInput, includeSeconds = false) => {
  if (!dateInput) return ''

  try {
    const date = new Date(dateInput)
    const year = date.getFullYear()
    const month = (date.getMonth() + 1).toString().padStart(2, '0')
    const day = date.getDate().toString().padStart(2, '0')
    const hours = date.getHours().toString().padStart(2, '0')
    const minutes = date.getMinutes().toString().padStart(2, '0')
    
    if (includeSeconds) {
      const seconds = date.getSeconds().toString().padStart(2, '0')
      return `${year}/${month}/${day} ${hours}:${minutes}:${seconds}`
    } else {
      return `${year}/${month}/${day} ${hours}:${minutes}`
    }
  } catch (err) {
    console.error('日期格式化错误:', err)
    return String(dateInput)
  }
}

/**
 * 格式化为北京时间显示
 * @param {string|Date|number} dateInput - 日期字符串、Date对象或时间戳
 * @returns {string} 格式化后的北京时间字符串
 */
const formatBeijingTime = (dateInput) => {
  if (!dateInput) return ''

  try {
    const date = new Date(dateInput)
    
    // 转换为北京时间（UTC+8）
    const beijingDate = new Date(date.getTime() + 8 * 60 * 60 * 1000)
    
    const year = beijingDate.getUTCFullYear()
    const month = beijingDate.getUTCMonth() + 1
    const day = beijingDate.getUTCDate()
    const hours = beijingDate.getUTCHours().toString().padStart(2, '0')
    const minutes = beijingDate.getUTCMinutes().toString().padStart(2, '0')
    const seconds = beijingDate.getUTCSeconds().toString().padStart(2, '0')

    return `${year}年${month}月${day}日 ${hours}时${minutes}分${seconds}秒`
  } catch (err) {
    console.error('北京时间格式化错误:', err)
    return String(dateInput)
  }
}

/**
 * 获取今天的开始时间
 * @returns {Date} 今天的开始时间（00:00:00）
 */
const getTodayStart = () => {
  const today = new Date()
  today.setHours(0, 0, 0, 0)
  return today
}

/**
 * 获取今天的结束时间
 * @returns {Date} 今天的结束时间（23:59:59）
 */
const getTodayEnd = () => {
  const today = new Date()
  today.setHours(23, 59, 59, 999)
  return today
}

/**
 * 获取指定天数前的日期
 * @param {number} days - 天数
 * @returns {Date} 指定天数前的日期
 */
const getDaysAgo = (days) => {
  const date = new Date()
  date.setDate(date.getDate() - days)
  return date
}

/**
 * 获取指定天数后的日期
 * @param {number} days - 天数
 * @returns {Date} 指定天数后的日期
 */
const getDaysLater = (days) => {
  const date = new Date()
  date.setDate(date.getDate() + days)
  return date
}

/**
 * 计算两个日期之间的天数差
 * @param {string|Date|number} date1 - 第一个日期
 * @param {string|Date|number} date2 - 第二个日期
 * @returns {number} 天数差（正数表示date1在date2之后）
 */
const getDaysDiff = (date1, date2) => {
  const d1 = new Date(date1)
  const d2 = new Date(date2)
  const diffTime = d1.getTime() - d2.getTime()
  return Math.ceil(diffTime / (1000 * 60 * 60 * 24))
}

/**
 * 格式化时长（秒转换为时分秒）
 * @param {number} seconds - 秒数
 * @returns {string} 格式化后的时长字符串
 */
const formatDuration = (seconds) => {
  if (!seconds || seconds < 0) return '0秒'
  
  const hours = Math.floor(seconds / 3600)
  const minutes = Math.floor((seconds % 3600) / 60)
  const secs = seconds % 60
  
  if (hours > 0) {
    return `${hours}小时${minutes}分钟${secs}秒`
  } else if (minutes > 0) {
    return `${minutes}分钟${secs}秒`
  } else {
    return `${secs}秒`
  }
}

/**
 * 检查日期是否有效
 * @param {any} date - 要检查的日期
 * @returns {boolean} 是否为有效日期
 */
const isValidDate = (date) => {
  const d = new Date(date)
  return d instanceof Date && !isNaN(d.getTime())
}

module.exports = {
  formatTime,
  formatDate,
  formatDateTime,
  formatBeijingTime,
  isSameDay,
  getTodayStart,
  getTodayEnd,
  getDaysAgo,
  getDaysLater,
  getDaysDiff,
  formatDuration,
  isValidDate
}
